home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Tools / Languages / MacMETH 3.2.1 / Sources / MacC3.3 / M2EA.MOD < prev    next >
Encoding:
Text File  |  1994-11-11  |  53.9 KB  |  544 lines  |  [TEXT/MEDT]
  1. ;
  2.   FROM M2SA IMPORT
  3.           Symbol, Mark;
  4.   FROM M2HA IMPORT
  5.           D0, D1, SB, MP, SP,
  6.           byte, word, long,
  7.           Condition, RegType, Register,
  8.           WidType, ItemMode, ItSet, Item, curLev,
  9.           LongVal, WordVal, SimpleC, SignedT, SimpleT, RealT,
  10.           GetReg, Release, ReleaseReg, LockReg, UnlockReg, SetbusyReg,
  11.           Isz, SetregMd, SetconMd, SetglbMd, SetstkMd,
  12.           InvertCC, Jf, StackTop, GenHalt,
  13.           LoadAdr, LoadD, LoadP, LoadX, Move, MoveAdr,
  14.           Neg1, Abs1, Cap1, Tst1, Com1, Inc1, Dec1,
  15.           Add2, Sub2, And2, Or2, Eor2, Div2, Mod2,
  16.           Mul2, Cmp2, In2, ShiType, Shi2, Ash2,
  17.           ConvertTyp, ConIndex, VarIndex, GetHigh, Normalize, CheckPointer,
  18.           CheckHigh, CheckClimit, CheckRange, CheckDbltoSingle, PreLoad,
  19.           FMove, LoadF, FMonad, FDyad;
  20.   FROM M2LA IMPORT
  21.           PutWord, maxP, maxM,
  22.           FixLink, fixup, MergedLinks;
  23.  
  24.  
  25.  
  26.   VAR
  27.           mask   :  ARRAY [ 0 .. 32 ] OF LONGINT;
  28.           wtab   :  ARRAY [ 0..wtabmax ] OF
  29.                       RECORD
  30.                         witem, mitem : Item;
  31.                         locked : BOOLEAN
  32.                       END;
  33.  
  34.  
  35.   PROCEDURE err(n : INTEGER);
  36.     (* local synonym for M2SM.Mark *)
  37.   BEGIN
  38.      Mark(n);
  39.   END err;
  40.  
  41.   PROCEDURE Put16(w : WORD);
  42.     (* local synonym for M2LM.PutWord *)
  43.   BEGIN
  44.     PutWord(w);
  45.   END Put16;
  46.  
  47.   PROCEDURE IncAdr(VAR adr : INTEGER; s : INTEGER);
  48.   BEGIN
  49.     IF (adr >= 0) & (s <= MaxInt - adr) OR
  50.        (adr <  0) & (s >= MinInt - adr) THEN adr := adr + s
  51.     ELSE err(211) (* address overflow/underflow *)
  52.     END;
  53.   END IncAdr;
  54.  
  55.   PROCEDURE AllocVar(obj : ObjPtr; VAR adr : INTEGER);
  56.     VAR s : INTEGER;
  57.   BEGIN
  58.     (* obj^.class = Var *)
  59.     WITH obj^ DO
  60.       (* allocate always an even number of bytes :   *)
  61.       (* so adr should never be set to an odd value. *)
  62.       s := typ^.size; IF ODD(s) THEN INC(s) END;
  63.       (* negative allocation for global and local variables *)
  64.       IncAdr(adr, -s); vadr := adr;
  65.     END (*WITH*);
  66.   END AllocVar;
  67.  
  68.   PROCEDURE AllocPar(par : ParPtr; VAR adr : INTEGER);
  69.     CONST PointerSize = 4;
  70.     VAR   s : INTEGER;
  71.   BEGIN
  72.     WITH par^ DO
  73.       s := typ^.size;
  74.       (* always word-alignment for parameters on stack : *)
  75.       IF ODD(s) THEN INC(s) END;
  76.       IF (typ^.form = Array) & typ^.dyn THEN
  77.         (* s = size of formal type for dynamic array parameter *)
  78.         IncAdr(adr, -s)
  79.       ELSIF varpar THEN
  80.         IncAdr(adr, -PointerSize)
  81.       ELSE
  82.         IncAdr(adr, -s)
  83.       END;
  84.     END (*WITH*);
  85.   END AllocPar;
  86.  
  87.   PROCEDURE AllocFld(obj : ObjPtr; VAR adr : INTEGER);
  88.     CONST ByteSize = 1;
  89.     VAR   s : INTEGER;
  90.   BEGIN
  91.     (* obj^.class = Field *)
  92.     WITH obj^ DO
  93.       s := typ^.size;
  94.       IF NOT((typ^.form <= Opaque) & (s = ByteSize)) THEN
  95.         (* word-alignment for structured types and *)
  96.         (* types with a size > ByteSize.           *)
  97.         IF ODD(adr) THEN INC(adr) END;
  98.       END;
  99.       offset := adr;
  100.       IncAdr(adr, s)
  101.     END (*WITH*);
  102.   END AllocFld;
  103.  
  104.   PROCEDURE SRTest(VAR x : Item);
  105.   BEGIN
  106.     WITH x DO
  107.       WHILE typ^.form = Range DO typ := typ^.RBaseTyp END;
  108.     END (*WITH*);
  109.   END SRTest;
  110.  
  111.   PROCEDURE setCC(VAR x : Item; fcc : Condition);
  112.   BEGIN
  113.     Release(x);
  114.     WITH x DO
  115.       typ := booltyp; mode := cocMd; CC := fcc;
  116.       Tjmp := 0; Fjmp := 0;
  117.     END;
  118.   END setCC;
  119.  
  120.   PROCEDURE SetBaseLimits(VAR x : Item; VAR lo, hi : INTEGER);
  121.     VAR sz : WidType; mi, ma : INTEGER;
  122.   BEGIN
  123.     (* x.typ^.form = Set *)
  124.     Isz(x,sz); (* take width of set before type is changed *)
  125.     WITH x DO
  126.       typ := typ^.SBaseTyp;
  127.       IF typ^.form = Enum THEN
  128.         mi := 0; ma := typ^.NofConst - 1;
  129.       ELSIF typ^.form = Range THEN
  130.         mi := typ^.min; ma := typ^.max;
  131.         typ := typ^.RBaseTyp;
  132.       ELSE
  133.         mi := 0; ma := ASH(8, sz) - 1;
  134.       END;
  135.     END (*WITH*);
  136.     lo := mi;
  137.     hi := ma;
  138.   END SetBaseLimits;
  139.  
  140.   PROCEDURE ConnectToWith(VAR x : Item; flev : INTEGER);
  141.   BEGIN
  142.     IF (flev > 0) & (flev <= wtabmax) & (flev <= wlev) THEN
  143.       (* caution : typ of item is changed. *)
  144.       THEN
  145.                   IF (xval.I >= 0) & (yval.I <= MaxInt - xval.I) OR
  146.                      (xval.I <  0) & (yval.I >= MinInt - xval.I) THEN
  147.                     xval.I := xval.I + yval.I
  148.                   ELSE err(206)
  149.                   END
  150.                 ELSIF f = Real THEN
  151.                   IF (xval.R >= 0.0) & (yval.R <= MAX(REAL) - xval.R) OR
  152.                      (xval.R <  0.0) & (yval.R >= MIN(REAL) - xval.R) THEN
  153.                     xval.R := xval.R + yval.R
  154.                   ELSE err(206)
  155.                   END
  156.                 ELSIF f = LongReal THEN
  157.                   IF (xval.X >= 0.0D) & (yval.X <= MAX(LONGREAL) - xval.X) OR
  158.                      (xval.X <  0.0D) & (yval.X >= MIN(LONGREAL) - xval.X) THEN
  159.                     xval.X := xval.X + yval.X
  160.                   ELSE err(206)
  161.                   END
  162.                 ELSIF f = Set THEN
  163.                   xval.S  := xval.S  + yval.S
  164.                 ELSIF f = Double THEN
  165.                   xval.D := xval.D + yval.D
  166.                 ELSE err(123)
  167.                 END;
  168.  
  169.       | minus : IF f = Int THEN
  170.                   IF (xval.I >= 0) &
  171.                      ((yval.I >= 0) OR (xval.I <= MaxInt + yval.I)) OR
  172.                      (xval.I < 0) &
  173.                      ((yval.I <  0) OR (xval.I >= MinInt + yval.I)) THEN
  174.                     xval.I := xval.I - yval.I
  175.                   ELSE err(207)
  176.                   END
  177.                 ELSIF f = Real THEN
  178.                   IF (yval.R >= 0.0) & (yval.R <= MAX(REAL)) &
  179.                      (ABS(xval.R) <= MAX(REAL)) & (xval.R >= (MIN(REAL) + yval.R)) THEN
  180.                     xval.R := xval.R - yval.R
  181.                   ELSIF (yval.R < 0.0) & (yval.R >= MIN(REAL)) &
  182.                      (ABS(xval.R) <= MAX(REAL)) & (xval.R <= (MAX(REAL) + yval.R)) THEN
  183.                     xval.R := xval.R - yval.R
  184.                   ELSE err(207)
  185.                   END
  186.                 ELSIF f = LongReal THEN
  187.                   IF (yval.X >= 0.0D) &
  188.                      (yval.X <= MAX(LONGREAL)) & (ABS(xval.X) <= MAX(LONGREAL)) &
  189.                      (xval.X >= (MIN(LONGREAL) + yval.X)) THEN
  190.                     xval.X := xval.X - yval.X
  191.                   ELSIF (yval.X < 0.0D) &
  192.                     (yval.X >= MIN(LONGREAL)) & (ABS(xval.X) <= MAX(LONGREAL)) &
  193.                     (xval.X <= (MAX(LONGREAL) + yval.X)) THEN
  194.                     xval.X := xval.X - yval.X
  195.                   ELSE err(207)
  196.                   END
  197.                 ELSIF f = Set THEN
  198.                   xval.S  := xval.S  - yval.S
  199.                 ELSIF f = Double THEN
  200.                   xval.D := xval.D - yval.D
  201.                 ELSE err(124)
  202.                 END;
  203.  
  204.       | or :    IF f = Bool THEN xval.B := xval.B OR yval.B
  205.                 ELSE err(125)
  206.                 END;
  207.  
  208.       | eql :   IF    f = Int    THEN xval.B := xval.I  =  yval.I
  209.                 ELSIF f = Real   THEN xval.B := xval.R  =  yval.R
  210.                 ELSIF f = Bool   THEN xval.B := xval.B  =  yval.B
  211.                 ELSIF f = Char   THEN xval.B := xval.Ch =  yval.Ch
  212.                 ELSIF f = Double THEN xval.B := xval.D  =  yval.D
  213.                 ELSIF f = Set    THEN xval.B := xval.S  =  yval.S
  214.                 ELSIF f = Enum   THEN xval.B := xval.Ch =  yval.Ch
  215.                 ELSIF f = LongReal THEN xval.B := xval.X = yval.X
  216.                 ELSE err(126)
  217.                 END;
  218.                 x.typ := booltyp;
  219.  
  220.       | neq :   IF    f = Int    THEN xval.B := xval.I  #  yval.I
  221.                 ELSIF f = Real   THEN xval.B := xval.R  #  yval.R
  222.                 ELSIF f = Bool   THEN xval.B := xval.B  #  yval.B
  223.                 ELSIF f = Char   THEN xval.B := xval.Ch #  yval.Ch
  224.                 ELSIF f = Double THEN xval.B := xval.D  #  yval.D
  225.                 ELSIF f = Set    THEN xval.B := xval.S  #  yval.S
  226.                 ELSIF f = Enum   THEN xval.B := xval.Ch #  yval.Ch
  227.                 ELSIF f = LongReal THEN xval.B := xval.X # yval.X
  228.                 ELSE err(126)
  229.                 END;
  230.                 x.typ := booltyp;
  231.  
  232.       | lss :   IF    f = Int    THEN xval.B := xval.I  <   yval.I
  233.                 ELSIF f = Real   THEN xval.B := xval.R  <   yval.R
  234.                 ELSIF f = Bool   THEN xval.B := xval.B  <   yval.B
  235.                 ELSIF f = Char   THEN xval.B := xval.Ch <   yval.Ch
  236.                 ELSIF f = Double THEN xval.B := xval.D  <   yval.D
  237.                 ELSIF f = Enum   THEN xval.B := xval.Ch <   yval.Ch
  238.                 ELSIF f = LongReal THEN xval.B := xval.X <  yval.X
  239.                 ELSE err(126)
  240.                 END;
  241.                 x.typ := booltyp;
  242.  
  243.       | leq :   IF    f = Int    THEN xval.B := xval.I  <=  yval.I
  244.                 ELSIF f = Real   THEN xval.B := xval.R  <=  yval.R
  245.                 ELSIF f = Bool   THEN xval.B := xval.B  <=  yval.B
  246.                 ELSIF f = Char   THEN xval.B := xval.Ch <=  yval.Ch
  247.                 ELSIF f = Double THEN xval.B := xval.D  <=  yval.D
  248.                 ELSIF f = Set    THEN xval.B := xval.S  <=  yval.S
  249.                 ELSIF f = Enum   THEN xval.B := xval.Ch <=  yval.Ch
  250.                 ELSIF f = LongReal THEN xval.B := xval.X <= yval.X
  251.                 ELSE err(126)
  252.                 END;
  253.                 x.typ := booltyp;
  254.  
  255.       | gtr :   IF    f = Int    THEN xval.B := xval.I   >  yval.I
  256.                 ELSIF f = Real   THEN xval.B := xval.R   >  yval.R
  257.                 ELSIF f = Bool   THEN xval.B := xval.B   >  yval.B
  258.                 ELSIF f = Char   THEN xval.B := xval.Ch  >  yval.Ch
  259.                 ELSIF f = Double THEN xval.B := xval.D   >  yval.D
  260.                 ELSIF f = Enum   THEN xval.B := xval.Ch  >  yval.Ch
  261.                 ELSIF f = LongReal THEN xval.B := xval.X  > yval.X
  262.                 ELSE err(126)
  263.                 END;
  264.                 x.typ := booltyp;
  265.  
  266.       | geq :   IF    f = Int    THEN xval.B := xval.I  >=  yval.I
  267.                 ELSIF f = Real   THEN xval.B := xval.R  >=  yval.R
  268.                 ELSIF f = Bool   THEN xval.B := xval.B  >=  yval.B
  269.                 ELSIF f = Char   THEN xval.B := xval.Ch >=  yval.Ch
  270.                 ELSIF f = Double THEN xval.B := xval.D  >=  yval.D
  271.                 ELSIF f = Set    THEN xval.B := xval.S  >=  yval.S
  272.                 ELSIF f = Enum   THEN xval.B := xval.Ch >=  yval.Ch
  273.                 ELSIF f = LongReal THEN xval.B := xval.X >= yval.X
  274.                 ELSE err(126)
  275.                 END;
  276.                 x.typ := booltyp;
  277.  
  278.       END (*CASE op*);
  279.       WITH xx DO
  280.         mode := conMd; typ := x.typ; val := xval;
  281.       END;
  282.       (* re-transform to 'conMd' *)
  283.       IF (f # Real) & (f # LongReal) THEN SetconMd(x, LongVal(xx), x.typ)
  284.       ELSE x := xx
  285.       END;
  286.  
  287.     ELSE (* NOT(x.mode = conMd) & (y.mode = conMd)) *)
  288.  
  289.       IF (x.mode = stkMd) & (y.mode = stkMd) THEN
  290.         (* if both items on stack, y must be loaded first. *)
  291.         IF SimpleT(x) & SimpleT(y) THEN LoadD(y)
  292.         ELSIF RealT(x) & RealT(y) THEN LoadF(y)
  293.         END;
  294.       END;
  295.  
  296.       PreLoad(op, x, y); (* preload x and y : No-op for real types *)
  297.  
  298.       CASE op OF
  299.  
  300.         times : IF (f = Int) OR (f = Double) OR (f = LWord) THEN
  301.                   Mul2(x,y)
  302.                 ELSIF (f = Real) OR (f = LongReal) THEN
  303.                   FDyad(times,x,y)
  304.                 ELSIF f = Set THEN
  305.                   And2(x,y)
  306.                 ELSE err(118)
  307.                 END;
  308.  
  309.       | slash : IF (f = Real) OR (f = LongReal) THEN
  310.                   FDyad(slash,x,y)
  311.                 ELSIF f = Set THEN
  312.                   Eor2(x,y)
  313.                 ELSE err(119)
  314.                 END;
  315.  
  316.       | div :   IF (f = Int) OR (f = Double) OR (f = LWord) THEN
  317.                   Div2(x,y)
  318.                 ELSE err(120)
  319.                 END;
  320.  
  321.       | rem :   IF (f = Int) OR (f = Double) OR (f = LWord) THEN
  322.                   err(200)
  323.                 ELSE err(121)
  324.                 END;
  325.  
  326.       | mod :   IF (f = Int) OR (f = Double) OR (f = LWord) THEN
  327.                   Mod2(x,y)
  328.                 ELSE err(121)
  329.                 END;
  330.  
  331.       | and :   IF x.mode = conMd THEN
  332.                   IF x.val.B THEN
  333.                     IF y.mode <= DregMd THEN
  334.                       Tst1(y); setCC(y,EQ);
  335.                     ELSIF y.mode # cocMd THEN err(122)
  336.                     END;
  337.                   ELSE setCC(y,T);
  338.                       restyp := inttyp
  339.                    ELSIF f = LongReal THEN
  340.                      FMonad(Short,x);
  341.                      restyp := realtyp
  342.                    ELSE err(144)
  343.                    END;
  344.  
  345.         | Size :   IF mode < conMd THEN
  346.                      IF (typ^.form = Array) & typ^.dyn THEN
  347.                        i := typ^.ElemTyp^.size;
  348.                        (* Caution: type is changed by GetHigh! *)
  349.                        GetHigh(x);
  350.                        LoadD(x);
  351.                        Inc1(x);
  352.                        SetconMd(y, i, typ);
  353.                        Mul2(x,y);
  354.                        (* resulting type defined by M2TM! *)
  355.                      ELSE
  356.                        Release(x);
  357.                        SetconMd(x, typ^.size, restyp);
  358.                      END;
  359.                    ELSIF mode = typMd THEN
  360.                      SetconMd(x, typ^.size, restyp);
  361.                    ELSE
  362.                      err(144); Release(x);
  363.                      SetconMd(x, 0D, restyp);
  364.                    END;
  365.  
  366.         | Tsize :  IF mode = typMd THEN i := typ^.size
  367.                    ELSE err(145); Release(x); i := 0 END;
  368.                    SetconMd(x, i, restyp);
  369.  
  370. (*f*)   | Long :   restyp := undftyp;
  371.                    (* 1 parameter required, 2. parameter optional : *)
  372.                    IF NOT morepar THEN
  373.                      (* LONG with only one parameter : *)
  374.                      IF ((f >= Byte) & (f <= Word)) OR (f = Set) THEN
  375.                        IF mode = conMd THEN
  376.                          SetconMd(x, LongVal(x), restyp)
  377.                        ELSE
  378.                          LoadX(x,long)
  379.                        END;
  380.                        restyp := dbltyp
  381.                      ELSIF f = Real THEN
  382.                        IF mode = conMd THEN
  383.                          val.X := LONG(val.R);
  384.                          typ := lrltyp
  385.                        ELSE FMonad(Long,x)
  386.                        END;
  387.                        restyp := lrltyp
  388.                      ELSE
  389.                        err(144); Release(x)
  390.                      END;
  391.                    ELSE
  392.                      (* LONG with 2 parameters : *)
  393.                      IF (f = Int) OR (f = Word) THEN restyp := typ (* see you *)
  394.                      ELSE err(144); Release(x)
  395.                      END;
  396.                    END;
  397.  
  398. (*p*)   | Dec,Inc: (* 1 parameter required, 2. parameter optional : *)
  399.                    z := x; SRTest(z);
  400.                    f := z.typ^.form; (* f is form of the base type *)
  401.                    IF NOT morepar THEN
  402.                      (* DEC/INC with only one parameter : *)
  403.                      IF (mode < conMd) & ((f >= Byte) & (f <= Double)) THEN
  404.                        f := x.typ^.form; (* f is form of original the type *)
  405.                        IF rngchk & ((f = Bool) OR (f = Char) OR (f = Enum) OR
  406.                                     (f = Range)) THEN
  407.                          IF f = Range THEN lo := x.typ^.min; hi := x.typ^.max;
  408.                          ELSIF f = Bool THEN lo := 0; hi := 1;
  409.                          ELSIF f = Char THEN lo := 0; hi := 255;
  410.                          ELSIF f = Enum THEN lo := 0; hi := x.typ^.NofConst - 1;
  411.                          END;
  412.                          LoadX(z,word); z.typ := inttyp;
  413.                          IF fctno = Dec THEN Dec1(z) ELSE Inc1(z) END;
  414.                          CheckRange(z, lo, hi, 0);
  415.                          z.typ := x.typ; (* recover original type *)
  416.                          Move(z,x); Release(z);
  417.                        ELSE
  418.                          IF fctno = Dec THEN Dec1(x) ELSE Inc1(x) END;
  419.                        END;
  420.                      ELSE err(144)
  421.                      END;
  422.                    ELSE
  423.                      (* DEC/INC with 2 parameters : *)
  424.                      IF (mode < conMd) & ((f = Int) OR (f = Double) OR (f = LWord)) THEN
  425.                        restyp := x.typ; (* the original type of x! *)
  426.                      ELSE err(144)
  427.                      END;
  428.                    END;
  429.  
  430. (*p*)   | Excl,
  431.           Incl :   IF NOT morepar THEN err(144) (* 2 parameters required *)
  432.                    ELSE
  433.                      IF (mode < conMd) & (f = Set) THEN
  434.                        restyp := typ; (* see you later *)
  435.                      ELSE err(144)
  436.                      END;
  437.                    END;
  438.  
  439. (*p*)   | Inline : IF (mode = conMd) & (f = Int) THEN Put16(val.I)
  440.                    ELSE err(144)
  441.                    END;
  442.  
  443. (*p*)   | Setreg : IF NOT morepar THEN err(144) (* 2 parameters required *)
  444.                    ELSE
  445.                      IF (mode = conMd) & (f = Int) & (val.I >= 0) THEN
  446.                        restyp := typ; (* see you later *)
  447.                      ELSE err(144)
  448.                      END;
  449.                    END;
  450.  
  451.         | Sqrt :   IF (f = Real) OR (f = LongReal) THEN
  452.                      restyp := typ; (* same type as argument type! *)
  453.                      FMonad(fctno,x);
  454.                    ELSE err(144)
  455.                    END;
  456.  
  457.         | Trunc :  IF (f = Real) OR (f = LongReal) THEN
  458.                      IF (mode = conMd) & (f = Real) THEN
  459.                        IF (FLOAT(MinInt) <= val.R) &
  460.                           (val.R <= FLOAT(MaxInt)) THEN
  461.                          li := TRUNC(val.R);
  462.                        ELSE
  463.                          li := 0; err(138);
  464.                        END;
  465.                        SetconMd(x, li, inttyp);
  466.                      ELSE (* variables and longreals *)
  467.                        (* M2TM defines the resulting type! *)
  468.                        FMonad(fctno,x)
  469.                      END
  470.                    ELSE err(144)
  471.                    END;
  472.  
  473.         | TruncD,
  474.           Entier,
  475.           Round :  IF (f = Real) OR (f = LongReal) THEN
  476.                      (* M2TM defines the resulting type! *)
  477.                      FMonad(fctno,x);
  478.                    ELSE err(144)
  479.                    END;
  480.  
  481. (*f*)   | XAsh, XLsh, XRot, XMsk :
  482.                    IF NOT morepar THEN err(144)
  483.                    ELSE
  484.                      IF SimpleT(x) THEN restyp := typ
  485.                      ELSE err(144); Release(x)
  486.                      END
  487.                    END;
  488.  
  489. (*f*)   | Val :    (* VAL as a replacement for the type transfers *)
  490.                    restyp := undftyp;
  491.                    IF NOT morepar THEN err(144)
  492.                    ELSE
  493.                      IF (mode = typMd) THEN restyp := typ
  494.                      ELSE err(144); Release(x)
  495.                      END
  496.                    END;
  497.  
  498.         | NonStand :
  499.         ELSE err(200)
  500.         END (*CASE*);
  501.         p := x;
  502.         p.typ := restyp;
  503.         IF restyp = notyp THEN Release(x) END;
  504.  
  505.       ELSIF parno = 1 THEN (* 2. Parameter *)
  506.         SRTest(x);
  507.         f := typ^.form;
  508.  
  509.         CASE fctno OF
  510.  
  511. (*f*)     Long :   IF (p.typ # undftyp) THEN
  512.                      IF (f = Int) OR (f = Word) THEN
  513.                        LoadD(x); x.typ := inttyp;
  514.                        (* Note : p is asserted of type INTEGER *)
  515.                        IF (p.mode = conMd) & (ABS(WordVal(p)) <= MaxInt) THEN
  516.                          li := ASH(LongVal(p), 16);
  517.                          SetconMd(p, li, dbltyp);
  518.                          LoadD(p);
  519.                        ELSE
  520.                          LoadD(p);
  521.                          SetconMd(y, 16D, inttyp);
  522.                          p.typ := dbltyp;
  523.                          Shi2(p,y,Lsl);   (* LSL.L *)
  524.                        END;
  525.                        p.typ := inttyp;
  526.                        Or2(p,x);          (* OR.W *)
  527.                        p.typ := dbltyp;   (* resulting type *)
  528.                        Release(x);
  529.                      ELSE
  530.                        err(144); Release(x);
  531.                      END;
  532.                    END;
  533.  
  534. (*p*)   | Dec,Inc: IF p.typ # notyp THEN
  535.                      restyp := p.typ;
  536.                      IF (restyp^.size >= typ^.size) & ((f = Int) OR (f = Double)) THEN
  537.                        IF mode = conMd THEN
  538.                          SetconMd(x, LongVal(x), restyp);
  539.                        ELSE
  540.                          Isz(p,sz);
  541.                          LoadX(x,sz);
  542.                          typ := restyp;
  543.                        END;
  544.